{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "72ea7293",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "numpy      : 1.23.4\n",
      "scipy      : 1.9.3\n",
      "torch      : 1.12.1\n",
      "pomegranate: 0.14.8\n",
      "\n",
      "Compiler    : GCC 11.2.0\n",
      "OS          : Linux\n",
      "Release     : 4.15.0-197-generic\n",
      "Machine     : x86_64\n",
      "Processor   : x86_64\n",
      "CPU cores   : 8\n",
      "Architecture: 64bit\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "import seaborn; seaborn.set_style('whitegrid')\n",
    "\n",
    "import time\n",
    "import torch\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from torchegranate.distributions import *\n",
    "from torchegranate.hmm import HiddenMarkovModel, Node\n",
    "\n",
    "from pomegranate import State, NormalDistribution, IndependentComponentsDistribution, DiscreteDistribution\n",
    "from pomegranate import HiddenMarkovModel as HMM\n",
    "\n",
    "numpy.random.seed(0)\n",
    "numpy.set_printoptions(suppress=True)\n",
    "\n",
    "%load_ext watermark\n",
    "%watermark -m -n -p numpy,scipy,torch,pomegranate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b312b25",
   "metadata": {},
   "source": [
    "### Normal Distribution w/ Diagonal Covariance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "412487ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:24: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:25: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    }
   ],
   "source": [
    "n, l, d = 200, 50, 10\n",
    "k = 50\n",
    "\n",
    "\n",
    "X = numpy.random.randn(n, l, d)\n",
    "Xt = torch.tensor(X)\n",
    "\n",
    "d1s, d2s, d3s = [], [], []\n",
    "for i in range(k):\n",
    "    mus = numpy.random.randn(d)\n",
    "\n",
    "    d1 = IndependentComponentsDistribution([NormalDistribution(mu, 1) for mu in mus])\n",
    "    d2 = Normal(torch.tensor(mus), torch.ones(d), covariance_type='diag')\n",
    "    d3 = Normal(torch.tensor(mus), torch.ones(d), covariance_type='diag')\n",
    "\n",
    "    d1s.append(d1)\n",
    "    d2s.append(d2)\n",
    "    d3s.append(d3)\n",
    "\n",
    "\n",
    "starts = torch.ones(k, dtype=torch.float64) / k\n",
    "ends = torch.ones(k, dtype=torch.float64) / (k+1)\n",
    "edges = torch.ones(k, k, dtype=torch.float64) / (k+1)\n",
    "\n",
    "\n",
    "model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
    "model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
    "model2.bake()\n",
    "model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
    "model3.bake()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6554dc39",
   "metadata": {},
   "source": [
    "### Forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e8291aa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "959 ms ± 7.29 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "184 ms ± 2.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "130 ms ± 2.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [model1.forward(x) for x in X]\n",
    "%timeit model2.forward(X)\n",
    "%timeit model3.forward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72667302",
   "metadata": {},
   "source": [
    "### Backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f709ef72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "995 ms ± 7.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "319 ms ± 42.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "133 ms ± 4.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [model1.backward(x) for x in X]\n",
    "%timeit model2.backward(X)\n",
    "%timeit model3.backward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d88fc2b3",
   "metadata": {},
   "source": [
    "### Forward-Backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fe16cb7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.58 s ± 10.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "801 ms ± 38.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "370 ms ± 39.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [model1.forward_backward(x) for x in X]\n",
    "%timeit model2.forward_backward(X)\n",
    "%timeit model3.forward_backward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41a0b064",
   "metadata": {},
   "source": [
    "### Fitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "016e640c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 11916.92540384506\tTime (s): 2.761\n",
      "[2] Improvement: 356.23982110453653\tTime (s): 2.799\n",
      "[3] Improvement: 187.82563967100577\tTime (s): 2.811\n",
      "[4] Improvement: 132.1274677386391\tTime (s): 2.817\n",
      "[5] Improvement: 107.64460236663581\tTime (s): 2.816\n",
      "[6] Improvement: 95.06285029207356\tTime (s): 2.816\n",
      "[7] Improvement: 87.14057147293352\tTime (s): 2.81\n",
      "[8] Improvement: 81.8166760643071\tTime (s): 2.814\n",
      "[9] Improvement: 78.61675650975667\tTime (s): 2.804\n",
      "[10] Improvement: 76.616654075915\tTime (s): 2.813\n",
      "Total Training Improvement: 13120.016443140863\n",
      "Total Training Time (s): 30.7974\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_49503/2413083255.py:2: DeprecationWarning: Calling np.sum(generator) is deprecated, and in the future will give a different result. Use np.sum(np.fromiter(generator)) or the python sum builtin instead.\n",
      "  sum(model1.log_probability(x) for x in X)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-141610.99530855467"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_ = model1.fit(X, max_iterations=10, verbose=True)\n",
    "sum(model1.log_probability(x) for x in X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c603db97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 11916.924049986032, Time: 0.9671s\n",
      "[2] Improvement: 356.2397617994575, Time: 0.8338s\n",
      "[3] Improvement: 187.8250123585749, Time: 0.8203s\n",
      "[4] Improvement: 132.1275977602927, Time: 0.8282s\n",
      "[5] Improvement: 107.64466150157386, Time: 0.8327s\n",
      "[6] Improvement: 95.062770339282, Time: 0.8272s\n",
      "[7] Improvement: 87.14074739645002, Time: 0.832s\n",
      "[8] Improvement: 81.81688827590551, Time: 0.8347s\n",
      "[9] Improvement: 78.61642209693673, Time: 0.8035s\n",
      "[10] Improvement: 76.61670887985383, Time: 1.664s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor(-141685.9139, dtype=torch.float64)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model2.fit(X)\n",
    "model2.log_probability(X).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "607d1627",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 11916.924035742384, Time: 0.3742s\n",
      "[2] Improvement: 356.2398789973522, Time: 0.4464s\n",
      "[3] Improvement: 187.82526078561204, Time: 0.4137s\n",
      "[4] Improvement: 132.12753497209633, Time: 0.3989s\n",
      "[5] Improvement: 107.64437899994664, Time: 0.3825s\n",
      "[6] Improvement: 95.06291119300295, Time: 0.4098s\n",
      "[7] Improvement: 87.14107854760368, Time: 0.399s\n",
      "[8] Improvement: 81.81658541041543, Time: 0.3975s\n",
      "[9] Improvement: 78.61654813570203, Time: 0.3884s\n",
      "[10] Improvement: 76.61647296641604, Time: 0.8219s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor(-141685.9138, dtype=torch.float64)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model3.fit(X)\n",
    "model3.log_probability(X).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e68ae32a",
   "metadata": {},
   "source": [
    "### Categorical Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "46dd6613",
   "metadata": {},
   "outputs": [],
   "source": [
    "n, l, d = 200, 50, 10\n",
    "k = 50\n",
    "\n",
    "\n",
    "X = numpy.random.choice(4, size=(n, l, d))\n",
    "Xt = torch.tensor(X)\n",
    "\n",
    "d1s, d2s, d3s = [], [], []\n",
    "for i in range(k):\n",
    "    mus = numpy.abs(numpy.random.randn(d, 4))\n",
    "    mus = mus / mus.sum(axis=1, keepdims=True)\n",
    "\n",
    "    d_ = [DiscreteDistribution({i: mu[i] for i in range(4)}) for mu in mus]\n",
    "    d1 = IndependentComponentsDistribution(d_)\n",
    "    d2 = Categorical(mus)\n",
    "    d3 = Categorical(mus)\n",
    "\n",
    "    d1s.append(d1)\n",
    "    d2s.append(d2)\n",
    "    d3s.append(d3)\n",
    "\n",
    "\n",
    "starts = torch.ones(k, dtype=torch.float64) / k\n",
    "ends = torch.ones(k, dtype=torch.float64) / k\n",
    "edges = torch.ones(k, k, dtype=torch.float64) / k\n",
    "\n",
    "\n",
    "model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
    "model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
    "model2.bake()\n",
    "model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
    "model3.bake()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8195331e",
   "metadata": {},
   "source": [
    "### Forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e6091b50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.02 s ± 9.35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "198 ms ± 2.94 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "150 ms ± 3.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [model1.forward(x) for x in X]\n",
    "%timeit model2.forward(X)\n",
    "%timeit model3.forward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa826b1",
   "metadata": {},
   "source": [
    "### Backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a4b5218d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.05 s ± 5.57 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "362 ms ± 39.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "150 ms ± 5.81 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [model1.backward(x) for x in X]\n",
    "%timeit model2.backward(X)\n",
    "%timeit model3.backward(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe327bb6",
   "metadata": {},
   "source": [
    "## Increased Size of Dense Transition Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c0521cb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 35/35 [10:45<00:00, 18.44s/it]\n"
     ]
    }
   ],
   "source": [
    "times1, times2, times3 = [], [], []\n",
    "\n",
    "for k in tqdm(range(10, 351, 10)):\n",
    "    n, l, d = 200, 50, 10\n",
    "\n",
    "    X = numpy.random.choice(4, size=(n, l, d))\n",
    "    Xt = torch.tensor(X)\n",
    "\n",
    "    d1s, d2s, d3s = [], [], []\n",
    "    for i in range(k):\n",
    "        mus = numpy.abs(numpy.random.randn(d, 4))\n",
    "        mus = mus / mus.sum(axis=1, keepdims=True)\n",
    "\n",
    "        d_ = [DiscreteDistribution({i: mu[i] for i in range(4)}) for mu in mus]\n",
    "        d1 = IndependentComponentsDistribution(d_)\n",
    "        d2 = Categorical(mus)\n",
    "        d3 = Categorical(mus)\n",
    "\n",
    "        d1s.append(d1)\n",
    "        d2s.append(d2)\n",
    "        d3s.append(d3)\n",
    "\n",
    "\n",
    "    starts = torch.ones(k, dtype=torch.float64) / k\n",
    "    ends = torch.ones(k, dtype=torch.float64) / (k+1)\n",
    "    edges = torch.ones(k, k, dtype=torch.float64) / (k+1)\n",
    "\n",
    "\n",
    "    model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
    "    model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
    "    model2.bake()\n",
    "    model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
    "    model3.bake()\n",
    "    \n",
    "    tic = time.time()\n",
    "    [model1.forward(x) for x in X]\n",
    "    times1.append(time.time() - tic)\n",
    "    \n",
    "    tic = time.time()\n",
    "    model2.forward(X)\n",
    "    times2.append(time.time() - tic)\n",
    "    \n",
    "    tic = time.time()\n",
    "    model3.forward(X)\n",
    "    times3.append(time.time() - tic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4e8f25a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = range(10, 351, 10)\n",
    "\n",
    "plt.figure(figsize=(6, 3))\n",
    "plt.title(\"HMM Forward Algorithm Time\", fontsize=12)\n",
    "plt.plot(x, times1, label=\"pomegranate\")\n",
    "plt.plot(x, times2, label=\"torchegranate sparse\")\n",
    "plt.plot(x, times3, label=\"torchegranate dense\")\n",
    "\n",
    "plt.xlabel(\"Number of Nodes\", fontsize=10)\n",
    "plt.ylabel(\"Time (s)\", fontsize=10)\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd8aa82c",
   "metadata": {},
   "source": [
    "## Increased Sparsity of Transition Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0ae5e00b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                    | 0/29 [00:00<?, ?it/s]/tmp/ipykernel_49503/3080411124.py:36: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  ends = torch.tensor(ends / z[:, 0])\n",
      "100%|███████████████████████████████████████████| 29/29 [38:23<00:00, 79.43s/it]\n"
     ]
    }
   ],
   "source": [
    "times1, times2, times3 = [], [], []\n",
    "ps = 1. / numpy.exp(numpy.arange(3, 10.1, 0.25))\n",
    "\n",
    "for p in tqdm(ps):\n",
    "    n, l, d = 200, 50, 10\n",
    "    k = 2000\n",
    "\n",
    "    X = numpy.random.choice(4, size=(n, l, d))\n",
    "    Xt = torch.tensor(X)\n",
    "\n",
    "    d1s, d2s, d3s = [], [], []\n",
    "    for i in range(k):\n",
    "        mus = numpy.abs(numpy.random.randn(d, 4))\n",
    "        mus = mus / mus.sum(axis=1, keepdims=True)\n",
    "\n",
    "        d_ = [DiscreteDistribution({i: mu[i] for i in range(4)}) for mu in mus]\n",
    "        d1 = IndependentComponentsDistribution(d_)\n",
    "        d2 = Categorical(mus)\n",
    "        d3 = Categorical(mus)\n",
    "\n",
    "        d1s.append(d1)\n",
    "        d2s.append(d2)\n",
    "        d3s.append(d3)\n",
    "\n",
    "\n",
    "    starts = torch.ones(k, dtype=torch.float64) / k\n",
    "    ends = torch.ones(k, dtype=torch.float64)\n",
    "    \n",
    "    edges = numpy.ones((k, k), dtype=numpy.float64)\n",
    "    mask = numpy.random.choice(2, size=(k, k), replace=True, p=[1-p, p])\n",
    "    \n",
    "    edges = edges * mask\n",
    "    z = edges.sum(axis=1, keepdims=True) + 1\n",
    "    \n",
    "    edges = torch.tensor(edges / z)\n",
    "    ends = torch.tensor(ends / z[:, 0])    \n",
    "\n",
    "    model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
    "    model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
    "    model2.bake()\n",
    "    model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
    "    model3.bake()\n",
    "    \n",
    "    tic = time.time()\n",
    "    [model1.forward(x) for x in X]\n",
    "    times1.append(time.time() - tic)\n",
    "    \n",
    "    tic = time.time()\n",
    "    model2.forward(X)\n",
    "    times2.append(time.time() - tic)\n",
    "    \n",
    "    tic = time.time()\n",
    "    model3.forward(X)\n",
    "    times3.append(time.time() - tic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "618d9f29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 3))\n",
    "plt.title(\"HMM Forward Algorithm Time\", fontsize=12)\n",
    "plt.plot(ps, times1, label=\"pomegranate\")\n",
    "plt.plot(ps, times2, label=\"torchegranate sparse\")\n",
    "plt.plot(ps, times3, label=\"torchegranate dense\")\n",
    "\n",
    "plt.xlabel(\"Proportion Non-zero\", fontsize=10)\n",
    "plt.ylabel(\"Time (s)\", fontsize=10)\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
